home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / email / message.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  14KB  |  524 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __all__ = [
  5.     'Message']
  6. import re
  7. import uu
  8. import binascii
  9. import warnings
  10. from cStringIO import StringIO
  11. import email.charset as email
  12. from email import utils
  13. from email import errors
  14. SEMISPACE = '; '
  15. paramre = re.compile('\\s*;\\s*')
  16. tspecials = re.compile('[ \\(\\)<>@,;:\\\\"/\\[\\]\\?=]')
  17.  
  18. def _formatparam(param, value = None, quote = True):
  19.     if value is not None and len(value) > 0:
  20.         if isinstance(value, tuple):
  21.             param += '*'
  22.             value = utils.encode_rfc2231(value[2], value[0], value[1])
  23.         
  24.         if quote or tspecials.search(value):
  25.             return '%s="%s"' % (param, utils.quote(value))
  26.         else:
  27.             return '%s=%s' % (param, value)
  28.     else:
  29.         return param
  30.  
  31.  
  32. def _parseparam(s):
  33.     plist = []
  34.     while s[:1] == ';':
  35.         s = s[1:]
  36.         end = s.find(';')
  37.         while end > 0 and s.count('"', 0, end) % 2:
  38.             end = s.find(';', end + 1)
  39.         if end < 0:
  40.             end = len(s)
  41.         
  42.         f = s[:end]
  43.         if '=' in f:
  44.             i = f.index('=')
  45.             f = f[:i].strip().lower() + '=' + f[i + 1:].strip()
  46.         
  47.         plist.append(f.strip())
  48.         s = s[end:]
  49.     return plist
  50.  
  51.  
  52. def _unquotevalue(value):
  53.     if isinstance(value, tuple):
  54.         return (value[0], value[1], utils.unquote(value[2]))
  55.     else:
  56.         return utils.unquote(value)
  57.  
  58.  
  59. class Message:
  60.     
  61.     def __init__(self):
  62.         self._headers = []
  63.         self._unixfrom = None
  64.         self._payload = None
  65.         self._charset = None
  66.         self.preamble = None
  67.         self.epilogue = None
  68.         self.defects = []
  69.         self._default_type = 'text/plain'
  70.  
  71.     
  72.     def __str__(self):
  73.         return self.as_string(unixfrom = True)
  74.  
  75.     
  76.     def as_string(self, unixfrom = False):
  77.         Generator = Generator
  78.         import email.Generator
  79.         fp = StringIO()
  80.         g = Generator(fp)
  81.         g.flatten(self, unixfrom = unixfrom)
  82.         return fp.getvalue()
  83.  
  84.     
  85.     def is_multipart(self):
  86.         return isinstance(self._payload, list)
  87.  
  88.     
  89.     def set_unixfrom(self, unixfrom):
  90.         self._unixfrom = unixfrom
  91.  
  92.     
  93.     def get_unixfrom(self):
  94.         return self._unixfrom
  95.  
  96.     
  97.     def attach(self, payload):
  98.         if self._payload is None:
  99.             self._payload = [
  100.                 payload]
  101.         else:
  102.             self._payload.append(payload)
  103.  
  104.     
  105.     def get_payload(self, i = None, decode = False):
  106.         if i is None:
  107.             payload = self._payload
  108.         elif not isinstance(self._payload, list):
  109.             raise TypeError('Expected list, got %s' % type(self._payload))
  110.         else:
  111.             payload = self._payload[i]
  112.         if decode:
  113.             if self.is_multipart():
  114.                 return None
  115.             
  116.             cte = self.get('content-transfer-encoding', '').lower()
  117.             None if cte == 'quoted-printable' else None<EXCEPTION MATCH>binascii.Error
  118.             if cte in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):
  119.                 sfp = StringIO()
  120.                 
  121.                 try:
  122.                     uu.decode(StringIO(payload + '\n'), sfp, quiet = True)
  123.                     payload = sfp.getvalue()
  124.                 except uu.Error:
  125.                     return payload
  126.                 except:
  127.                     None<EXCEPTION MATCH>uu.Error
  128.                 
  129.  
  130.             None<EXCEPTION MATCH>uu.Error
  131.         
  132.         return payload
  133.  
  134.     
  135.     def set_payload(self, payload, charset = None):
  136.         self._payload = payload
  137.         if charset is not None:
  138.             self.set_charset(charset)
  139.         
  140.  
  141.     
  142.     def set_charset(self, charset):
  143.         if charset is None:
  144.             self.del_param('charset')
  145.             self._charset = None
  146.             return None
  147.         
  148.         if isinstance(charset, basestring):
  149.             charset = email.charset.Charset(charset)
  150.         
  151.         if not isinstance(charset, email.charset.Charset):
  152.             raise TypeError(charset)
  153.         
  154.         self._charset = charset
  155.         if not self.has_key('MIME-Version'):
  156.             self.add_header('MIME-Version', '1.0')
  157.         
  158.         if not self.has_key('Content-Type'):
  159.             self.add_header('Content-Type', 'text/plain', charset = charset.get_output_charset())
  160.         else:
  161.             self.set_param('charset', charset.get_output_charset())
  162.         if str(charset) != charset.get_output_charset():
  163.             self._payload = charset.body_encode(self._payload)
  164.         
  165.         if not self.has_key('Content-Transfer-Encoding'):
  166.             cte = charset.get_body_encoding()
  167.             
  168.             try:
  169.                 cte(self)
  170.             except TypeError:
  171.                 self._payload = charset.body_encode(self._payload)
  172.                 self.add_header('Content-Transfer-Encoding', cte)
  173.             except:
  174.                 None<EXCEPTION MATCH>TypeError
  175.             
  176.  
  177.         None<EXCEPTION MATCH>TypeError
  178.  
  179.     
  180.     def get_charset(self):
  181.         return self._charset
  182.  
  183.     
  184.     def __len__(self):
  185.         return len(self._headers)
  186.  
  187.     
  188.     def __getitem__(self, name):
  189.         return self.get(name)
  190.  
  191.     
  192.     def __setitem__(self, name, val):
  193.         self._headers.append((name, val))
  194.  
  195.     
  196.     def __delitem__(self, name):
  197.         name = name.lower()
  198.         newheaders = []
  199.         for k, v in self._headers:
  200.             if k.lower() != name:
  201.                 newheaders.append((k, v))
  202.                 continue
  203.         
  204.         self._headers = newheaders
  205.  
  206.     
  207.     def __contains__(self, name):
  208.         return [] in [ k.lower() for k, v in self._headers ]
  209.  
  210.     
  211.     def has_key(self, name):
  212.         missing = object()
  213.         return self.get(name, missing) is not missing
  214.  
  215.     
  216.     def keys(self):
  217.         return [ k for k, v in self._headers ]
  218.  
  219.     
  220.     def values(self):
  221.         return [ v for k, v in self._headers ]
  222.  
  223.     
  224.     def items(self):
  225.         return self._headers[:]
  226.  
  227.     
  228.     def get(self, name, failobj = None):
  229.         name = name.lower()
  230.         for k, v in self._headers:
  231.             if k.lower() == name:
  232.                 return v
  233.                 continue
  234.         
  235.         return failobj
  236.  
  237.     
  238.     def get_all(self, name, failobj = None):
  239.         values = []
  240.         name = name.lower()
  241.         for k, v in self._headers:
  242.             if k.lower() == name:
  243.                 values.append(v)
  244.                 continue
  245.         
  246.         if not values:
  247.             return failobj
  248.         
  249.         return values
  250.  
  251.     
  252.     def add_header(self, _name, _value, **_params):
  253.         parts = []
  254.         for k, v in _params.items():
  255.             if v is None:
  256.                 parts.append(k.replace('_', '-'))
  257.                 continue
  258.             parts.append(_formatparam(k.replace('_', '-'), v))
  259.         
  260.         if _value is not None:
  261.             parts.insert(0, _value)
  262.         
  263.         self._headers.append((_name, SEMISPACE.join(parts)))
  264.  
  265.     
  266.     def replace_header(self, _name, _value):
  267.         _name = _name.lower()
  268.         for k, v in zip(range(len(self._headers)), self._headers):
  269.             if k.lower() == _name:
  270.                 self._headers[i] = (k, _value)
  271.                 break
  272.                 continue
  273.         else:
  274.             raise KeyError(_name)
  275.  
  276.     
  277.     def get_content_type(self):
  278.         missing = object()
  279.         value = self.get('content-type', missing)
  280.         if value is missing:
  281.             return self.get_default_type()
  282.         
  283.         ctype = paramre.split(value)[0].lower().strip()
  284.         if ctype.count('/') != 1:
  285.             return 'text/plain'
  286.         
  287.         return ctype
  288.  
  289.     
  290.     def get_content_maintype(self):
  291.         ctype = self.get_content_type()
  292.         return ctype.split('/')[0]
  293.  
  294.     
  295.     def get_content_subtype(self):
  296.         ctype = self.get_content_type()
  297.         return ctype.split('/')[1]
  298.  
  299.     
  300.     def get_default_type(self):
  301.         return self._default_type
  302.  
  303.     
  304.     def set_default_type(self, ctype):
  305.         self._default_type = ctype
  306.  
  307.     
  308.     def _get_params_preserve(self, failobj, header):
  309.         missing = object()
  310.         value = self.get(header, missing)
  311.         if value is missing:
  312.             return failobj
  313.         
  314.         params = []
  315.         for p in _parseparam(';' + value):
  316.             
  317.             try:
  318.                 (name, val) = p.split('=', 1)
  319.                 name = name.strip()
  320.                 val = val.strip()
  321.             except ValueError:
  322.                 name = p.strip()
  323.                 val = ''
  324.  
  325.             params.append((name, val))
  326.         
  327.         params = utils.decode_params(params)
  328.         return params
  329.  
  330.     
  331.     def get_params(self, failobj = None, header = 'content-type', unquote = True):
  332.         missing = object()
  333.         params = self._get_params_preserve(missing, header)
  334.         if params is missing:
  335.             return failobj
  336.         
  337.  
  338.     
  339.     def get_param(self, param, failobj = None, header = 'content-type', unquote = True):
  340.         if not self.has_key(header):
  341.             return failobj
  342.         
  343.         for k, v in self._get_params_preserve(failobj, header):
  344.             if k.lower() == param.lower():
  345.                 if unquote:
  346.                     return _unquotevalue(v)
  347.                 else:
  348.                     return v
  349.             unquote
  350.         
  351.         return failobj
  352.  
  353.     
  354.     def set_param(self, param, value, header = 'Content-Type', requote = True, charset = None, language = ''):
  355.         if not isinstance(value, tuple) and charset:
  356.             value = (charset, language, value)
  357.         
  358.         if not self.has_key(header) and header.lower() == 'content-type':
  359.             ctype = 'text/plain'
  360.         else:
  361.             ctype = self.get(header)
  362.         if not self.get_param(param, header = header):
  363.             if not ctype:
  364.                 ctype = _formatparam(param, value, requote)
  365.             else:
  366.                 ctype = SEMISPACE.join([
  367.                     ctype,
  368.                     _formatparam(param, value, requote)])
  369.         else:
  370.             ctype = ''
  371.             for old_param, old_value in self.get_params(header = header, unquote = requote):
  372.                 append_param = ''
  373.                 if old_param.lower() == param.lower():
  374.                     append_param = _formatparam(param, value, requote)
  375.                 else:
  376.                     append_param = _formatparam(old_param, old_value, requote)
  377.                 if not ctype:
  378.                     ctype = append_param
  379.                     continue
  380.                 ctype = SEMISPACE.join([
  381.                     ctype,
  382.                     append_param])
  383.             
  384.         if ctype != self.get(header):
  385.             del self[header]
  386.             self[header] = ctype
  387.         
  388.  
  389.     
  390.     def del_param(self, param, header = 'content-type', requote = True):
  391.         if not self.has_key(header):
  392.             return None
  393.         
  394.         new_ctype = ''
  395.         for p, v in self.get_params(header = header, unquote = requote):
  396.             if p.lower() != param.lower():
  397.                 if not new_ctype:
  398.                     new_ctype = _formatparam(p, v, requote)
  399.                 else:
  400.                     new_ctype = SEMISPACE.join([
  401.                         new_ctype,
  402.                         _formatparam(p, v, requote)])
  403.             new_ctype
  404.         
  405.         if new_ctype != self.get(header):
  406.             del self[header]
  407.             self[header] = new_ctype
  408.         
  409.  
  410.     
  411.     def set_type(self, type, header = 'Content-Type', requote = True):
  412.         if not type.count('/') == 1:
  413.             raise ValueError
  414.         
  415.         if header.lower() == 'content-type':
  416.             del self['mime-version']
  417.             self['MIME-Version'] = '1.0'
  418.         
  419.         if not self.has_key(header):
  420.             self[header] = type
  421.             return None
  422.         
  423.         params = self.get_params(header = header, unquote = requote)
  424.         del self[header]
  425.         self[header] = type
  426.         for p, v in params[1:]:
  427.             self.set_param(p, v, header, requote)
  428.         
  429.  
  430.     
  431.     def get_filename(self, failobj = None):
  432.         missing = object()
  433.         filename = self.get_param('filename', missing, 'content-disposition')
  434.         if filename is missing:
  435.             filename = self.get_param('name', missing, 'content-disposition')
  436.         
  437.         if filename is missing:
  438.             return failobj
  439.         
  440.         return utils.collapse_rfc2231_value(filename).strip()
  441.  
  442.     
  443.     def get_boundary(self, failobj = None):
  444.         missing = object()
  445.         boundary = self.get_param('boundary', missing)
  446.         if boundary is missing:
  447.             return failobj
  448.         
  449.         return utils.collapse_rfc2231_value(boundary).rstrip()
  450.  
  451.     
  452.     def set_boundary(self, boundary):
  453.         missing = object()
  454.         params = self._get_params_preserve(missing, 'content-type')
  455.         if params is missing:
  456.             raise errors.HeaderParseError('No Content-Type header found')
  457.         
  458.         newparams = []
  459.         foundp = False
  460.         for pk, pv in params:
  461.             if pk.lower() == 'boundary':
  462.                 newparams.append(('boundary', '"%s"' % boundary))
  463.                 foundp = True
  464.                 continue
  465.             newparams.append((pk, pv))
  466.         
  467.         if not foundp:
  468.             newparams.append(('boundary', '"%s"' % boundary))
  469.         
  470.         newheaders = []
  471.         for h, v in self._headers:
  472.             if h.lower() == 'content-type':
  473.                 parts = []
  474.                 for k, v in newparams:
  475.                     if v == '':
  476.                         parts.append(k)
  477.                         continue
  478.                     parts.append('%s=%s' % (k, v))
  479.                 
  480.                 newheaders.append((h, SEMISPACE.join(parts)))
  481.                 continue
  482.             newheaders.append((h, v))
  483.         
  484.         self._headers = newheaders
  485.  
  486.     
  487.     def get_content_charset(self, failobj = None):
  488.         missing = object()
  489.         charset = self.get_param('charset', missing)
  490.         if charset is missing:
  491.             return failobj
  492.         
  493.         if isinstance(charset, tuple):
  494.             if not charset[0]:
  495.                 pass
  496.             pcharset = 'us-ascii'
  497.             
  498.             try:
  499.                 charset = unicode(charset[2], pcharset).encode('us-ascii')
  500.             except (LookupError, UnicodeError):
  501.                 charset = charset[2]
  502.             except:
  503.                 None<EXCEPTION MATCH>(LookupError, UnicodeError)
  504.             
  505.  
  506.         None<EXCEPTION MATCH>(LookupError, UnicodeError)
  507.         
  508.         try:
  509.             if isinstance(charset, str):
  510.                 charset = unicode(charset, 'us-ascii')
  511.             
  512.             charset = charset.encode('us-ascii')
  513.         except UnicodeError:
  514.             return failobj
  515.  
  516.         return charset.lower()
  517.  
  518.     
  519.     def get_charsets(self, failobj = None):
  520.         return [ part.get_content_charset(failobj) for part in self.walk() ]
  521.  
  522.     from email.Iterators import walk
  523.  
  524.